Assicuriamoci che il seguente notebook funzioni sia in python 2 che 3, importiamo alcuni moduli di utilità, abilitiamo il plotting delle figure di MatplotLib e prepriamo una funzione per salvare le immagini.
# Python ≥3.5 is required
import sys
assert sys.version_info >= (3, 5)
# Scikit-Learn ≥0.20 is required
import sklearn
assert sklearn.__version__ >= "0.20"
# Common imports
import numpy as np
import os
from datetime import datetime
from dateutil.parser import parse
#imports pandas
import pandas as ps
from IPython.display import Image
import os
#import warnings and Repress Warnings
import warnings
warnings.filterwarnings("ignore", message="numpy.dtype size changed")
warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
warnings.filterwarnings("ignore", message="numpy.ndarray size changed")
warnings.filterwarnings('ignore')
# to make this notebook's output stable across runs
np.random.seed(42)
# To plot pretty figures
%matplotlib inline
import matplotlib as mpl
import matplotlib.pyplot as plt
import seaborn as sns
sns.set(style="whitegrid") #White Grid
mpl.rc('axes', labelsize=14)
mpl.rc('xtick', labelsize=12)
mpl.rc('ytick', labelsize=12)
# Where to save the figures
PROJECT_ROOT_DIR = "."
CHAPTER_ID= "ProgettoFifa19"
IMAGES_PATH = os.path.join(PROJECT_ROOT_DIR, "images")
os.makedirs(IMAGES_PATH, exist_ok=True)
def save_fig(fig_id, tight_layout=True, fig_extension="png", resolution=400):
path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)
print("Saving figure", fig_id)
if tight_layout:
plt.tight_layout()
plt.savefig(path, format=fig_extension, dpi=resolution)
def save_figure(figure, fig_id, tight_layout=False, fig_extension="png", resolution=400):
path = os.path.join(IMAGES_PATH, fig_id + "." + fig_extension)
print("Saving figure", fig_id)
if tight_layout:
plt.tight_layout()
figure.savefig(path, format=fig_extension, dpi=resolution)
# Ignore useless warnings (see SciPy issue #5998)
import warnings
warnings.filterwarnings(action="ignore", message="^internal gelsd")
import warnings
warnings.filterwarnings('ignore')
# Hrule--> "====="
hrule = lambda x : "="*x
Hrule = lambda x,y: "="*(x//2)+y+"="*(x//2)
La COVID-19, o malattia respiratoria acuta da SARS-CoV-2 e più semplicemente malattia da coronavirus 2019 o anche morbo da coronavirus 2019,
è una malattia infettiva respiratoria causata dal virus denominato SARS-CoV-2 appartenente alla famiglia dei coronavirus.
I primi casi sono stati riscontrati durante la pandemia di COVID-19 del 2019-2020.
Image(filename=os.path.join(IMAGES_PATH, 'SARS-CoV-2.png'), width=600)
dataset = ps.read_csv("file/full_grouped.csv")
dataset.head()
Attraverso la funzione shape vediamo la dimensione del dataset (righe,colonne)
print(dataset.shape)
Verifichiamo la presenza di valori mancanti
dataset.info()
ps.DataFrame(dataset.isnull().sum()/dataset.shape[0]).T
dataset.describe()
Riordino le colonne derivanti dagli attributi, non vado a considerare le regioni pocihè mi interessano solo i paesi,
Inserisco come indice del mio DataFrame la data e per ogni data definisco gli attributi per ogni nazione.
dati={"Paese":np.array(dataset['Country/Region']),
"Confermati":np.array(dataset.Confirmed),
"Nuovi casi":np.array(dataset["New cases"]),
"Ricoverati":np.array(dataset.Recovered),
"Nuovi Ricoverati":np.array(dataset["New recovered"]),
"Morti":np.array(dataset.Deaths),
"Nuovi morti":np.array(dataset["New deaths"])
}
dates=[datetime.strptime(y, '%Y-%m-%d')for y in dataset.Date]
ts=ps.DataFrame(dati,index=dates)
ts
Per questioni di comodità mostro i record relativi alla data del 1-05-2020.
s=ts[datetime(2020, 5, 1):datetime(2020, 5, 1)]
s.loc[datetime(2020, 5, 1)]
Vediamo ad esempio la tupla contenente i dati esclusivamente relativi al Paese Italia nel giorno 1-05-2020
stati=np.array(dataset['Country/Region'])
c=-1
for i in stati:
c=c+1
if i=='Italy':
break
s.iloc[c]
Rieffettuiamo una analisi sui dati dopo aver modificato il Dataset
ts.info()
ps.DataFrame(ts.isnull().sum()/ts.shape[0]).T
Nessun attributo ha valori mancanti.
Ora per arricchire il nostro Dataset, Prendiamo un DataFrame esterno che contiene il livello di LockDown adattato per ogni singolo paese,
e lo inseriamo nei paesi di cui dispone il nostro Dataset, sfrtuttando le seguenti operazioni.
Una volta determinato il valore per ogni singolo paese dei 187 all'interno del Dataset originale, costruiamo una lista contenente i valori per ogni singolo Stato.
Alla fine sostituiamo i valori della colonna che corrisponde al Lockdown con quelli della lista da noi creata.
ts['Lockdown']='TOTALE'
paesi=ts[datetime(2020, 5, 1):datetime(2020, 5, 1)]
datasetLockdown = ps.read_csv("file/lockdown/countryLockdowndates.csv")
l=ps.DataFrame(datasetLockdown)
l=l.drop(['Reference','Province'],axis=1)
dati={"Paese":np.array(l['Country/Region']),
"Date":np.array(l['Date']),
"Type" :np.array(l['Type'])}
x=ps.DataFrame(dati)
j=0
f=0
for j in range(187):
if f==x.Paese.size:
break
if paesi.iloc[j].Paese==x.loc[f].Paese:
if x.loc[f].Type=='Partial':
paesi.xs(paesi.index[j].strftime('%Y-%m-%d')).Lockdown[j]='PARZIALE'
elif x.loc[f].Type=='Full':
paesi.xs(paesi.index[j].strftime('%Y-%m-%d')).Lockdown[j]='TOTALE'
else:
paesi.xs(paesi.index[j].strftime('%Y-%m-%d')).Lockdown[j]='NESSUNO'
f=f+1
else:
V=paesi.iloc[j].Paese
ver=False
indice=f
while(ver==False and indice< 186):
if V==x.loc[indice].Paese:
ver=True
break
indice=indice+1
bool=True
if(ver==False):
bool=False
else:
while(bool==True):
f=f+1
if paesi.iloc[j].Paese==x.loc[f].Paese:
if x.loc[f].Type=='Partial':
paesi.xs(paesi.index[j].strftime('%Y-%m-%d')).Lockdown[j]='PARZIALE'
elif x.loc[f].Type=='Full':
paesi.xs(paesi.index[j].strftime('%Y-%m-%d')).Lockdown[j]='TOTALE'
else:
paesi.xs(paesi.index[j].strftime('%Y-%m-%d')).Lockdown[j]='NESSUNO'
bool=False
lista=np.array(paesi.Lockdown)
dim=ts.index.size//lista.size
listaC=np.array(paesi.Lockdown)
for i in range (dim-1):
listaC=np.append(listaC,lista, axis=0)
ts.Lockdown=listaC
ts.head(1000)
Costruisco 3 grafici ognuno contente il numero dei Cofermati fino all'23-06-2020, però raggruppandoli in base al loro livello di Lockdown adattato.
Per fare cio mi definisco un metodo che mi costruisce le tre listre da plottare,
ognuna delle quali contiene i paesi e il loro corrispetivo valore di confermati raggruppati in base al livello di Lockdown.
Lockdown_=ts[datetime(2020, 6, 23):].reset_index(drop=True)
Lockdown_=Lockdown_.drop(['Nuovi casi','Ricoverati','Nuovi Ricoverati','Nuovi morti','Morti'],axis=1)
def Lock(liv,Lock):
for d in Lock.index:
LIV=Lock.Lockdown[d]
if liv!=LIV:
Lock=Lock.drop([d])
return Lock
Lockdown_Tot= Lock('TOTALE',Lockdown_.copy()).sort_values('Confermati').reset_index(drop=True)
Lockdown_Parz= Lock('PARZIALE',Lockdown_.copy()).sort_values('Confermati').reset_index(drop=True)
Lockdown_Nes= Lock('NESSUNO',Lockdown_.copy()).sort_values('Confermati').reset_index(drop=True)
Lockdown_Nes
confermati_TOT=np.array(Lockdown_Tot.Confermati)
labels = np.array(Lockdown_Tot.Paese)
plt.figure(figsize=(30,5))
sns.barplot(x=labels,y=confermati_TOT, palette='deep')
plt.ylabel("Numero confermati per Stato")
plt.xlabel("Stati",rotation=0)
plt.title("N° Confermati totali fino all'23 giugno per Paesi con Lockdown Totale",size = 20)
plt.xticks(rotation=90)
# save_fig("N° Confermati totali fino all'23 giugno per Paese con LockDown Totale")
confermati_Nes=np.array(Lockdown_Nes.Confermati)
labels = np.array(Lockdown_Nes.Paese)
plt.figure(figsize=(20,5))
sns.barplot(x=labels,y=confermati_Nes, palette='deep')
plt.ylabel("Numero confermati per Stato")
plt.xlabel("Stati",rotation=0)
plt.title("N° Confermati totali fino all'23 giugno per Paesi senza Lockdown ",size = 20)
plt.xticks(rotation=90)
# save_fig("N° Confermati totali fino all'23 giugno per Paese senza LockDown ")
confermati_Parz=np.array(Lockdown_Parz.Confermati)
labels = np.array(Lockdown_Parz.Paese)
print(max(confermati_TOT))
plt.figure(figsize=(20,5))
sns.barplot(x=labels,y=confermati_Parz, palette='deep')
plt.ylabel("Numero confermati per Stato")
plt.xlabel("Stati",rotation=0)
plt.title("N° Confermati totali fino all'23 giugno per Paesi con Lockdown Parziale ",size = 20)
plt.xticks(rotation=90)
# save_fig("N° Confermati totali fino all'23 giugno per Paese con LockDown Parziale")
Possiamo notare stranamente che i paesi che hanno adottato il lockdown hanno avuto moltissimi casi.
Tra quelli che non l'hanno adottato vediamo solamente il brasile che ha rilevato troppi casi a causa di questa scelta.
Per i paesi che hanno adattato un livello parziale di Lockdown non si hanno rilevato dati esageramente elevanti dall'inizio della pandemia.
x=ts[datetime(2020, 6, 23):]
x=x.sort_values('Confermati')
confermati_TOT=np.array(x.Confermati)
labels = np.array(x.Paese)
Casi_tot_TOP=ps.Series(confermati_TOT,index=labels)
for i in labels:
if Casi_tot_TOP[i]<15000:
Casi_tot_TOP=Casi_tot_TOP.drop(i)
plt.figure(figsize=(30,35))
sns.barplot(x=Casi_tot_TOP.values, y=Casi_tot_TOP.index,palette='deep')
plt.xlabel("Numero confermati per Stato")
plt.ylabel("Stati",rotation=0)
plt.title("N° Confermati totali fino all'23 giugno per Paese, considerando gli Stati aventi numero di casi >15000",size = 20)
plt.xticks(rotation=0)
# save_fig("N° Confermati totali fino all'23 giugno per Paese")
Prendiamo i 10 paesi e plottiamo il valore dei loro confermati risultati fino ad oggi 23 giugno.
confermati_TOTALI=np.array(ts[datetime(2020, 6, 23):].Confermati)
labels = np.array(ts[datetime(2020, 6, 23):].Paese)
Casi_tot_TOP_10=ps.Series(confermati_TOTALI,index=labels)
for i in labels:
if Casi_tot_TOP_10[i]<200000:
Casi_tot_TOP_10=Casi_tot_TOP_10.drop(i)
plt.figure(figsize=(10,6))
sns.barplot(x=Casi_tot_TOP_10.index, y=Casi_tot_TOP_10.values,palette='deep')
plt.ylabel("Numero confermati \n per Stato",rotation=90,size=18)
plt.xlabel("Stati",rotation=0,size=18)
plt.title("N° Confermati totali fino all'23 giugno top 10 Paesi",size = 25)
plt.xticks(rotation=0)
# save_fig("N° Confermati totali fino all'23 giugno top 10 Paesi")
Effettuamo una divisione del Dataset prendendo attraverso i metodi sotto esposti, i nuovi casi per ognuno dei paesi contenuti all'interno della lista dei TOP_10,
e per concludere definiamo un DataFrame che avrà 10 colonne ognuna delle quali rappresenterà i nuovi casi per il 1°.2°,3°,....,10° paese in tale lista.
NewDati={"Top 10 Stati": ts['Paese'],
"Nuovi casi":ts['Nuovi casi']}
Nuovi_Casi_Andamento_TOT=ps.DataFrame(NewDati,index=ts.index)
m=0
LISTA= np.array(Nuovi_Casi_Andamento_TOT['Top 10 Stati'])
L=Casi_tot_TOP_10.index
for i in LISTA:
if i!=L[0] and i!=L[1] and i!=L[2] and i!=L[3] and i!=L[4] and i!=L[5] and i!=L[6] and i!=L[7] and i!=L[8] and i!=L[9]:
Nuovi_Casi_Andamento_TOT.iloc[m] = np.nan
m=m+1
Nuovi_Casi_Andamento_TOT=Nuovi_Casi_Andamento_TOT.dropna()
def f(x,I):
LISTA= np.array(x['Top 10 Stati'])
m=0
for i in LISTA:
if i!=I :
x.iloc[m] = np.nan
m=m+1
return x
Brasile=f(Nuovi_Casi_Andamento_TOT.copy(),'Brazil').dropna()
Chile=f(Nuovi_Casi_Andamento_TOT.copy(),'Chile').dropna()
India=f(Nuovi_Casi_Andamento_TOT.copy(),'India').dropna()
Iran=f(Nuovi_Casi_Andamento_TOT.copy(),'Iran').dropna()
Italia=f(Nuovi_Casi_Andamento_TOT.copy(),'Italy').dropna()
Perù=f(Nuovi_Casi_Andamento_TOT.copy(),'Peru').dropna()
Russia=f(Nuovi_Casi_Andamento_TOT.copy(),'Russia').dropna()
Spagna=f(Nuovi_Casi_Andamento_TOT.copy(),'Spain').dropna()
USA=f(Nuovi_Casi_Andamento_TOT.copy(),'US').dropna()
Regno_Unito=f(Nuovi_Casi_Andamento_TOT.copy(),'United Kingdom').dropna()
CompletaDati={"NuoviCasi Brasile":Brasile['Nuovi casi'],
"NuoviCasi Chile":Chile['Nuovi casi'],
"NuoviCasi India":India['Nuovi casi'],
"NuoviCasi Iran":Iran['Nuovi casi'],
"NuoviCasi Italia":Italia['Nuovi casi'],
"NuoviCasi Perù":Perù['Nuovi casi'],
"NuoviCasi Russia":Russia['Nuovi casi'],
"NuoviCasi Spagna":Spagna['Nuovi casi'],
"NuoviCasi USA":USA['Nuovi casi'],
"NuoviCasi Regno_Unito":Regno_Unito['Nuovi casi']}
COMPLETO=ps.DataFrame(CompletaDati,index=Italia.index)
COMPLETO
Visualizziamo meglio i dati attraverso il seguente grafico.
#Brasile,Chile,India,Iran,Italia,Perù,Russia,Spagna,USA,Regno_Unito
COMPLETO['2020'].plot(figsize=(30,10),title="Andamento nuovi casi fino all'23 giugno top 10 Paesi",linewidth=2, markersize=20)
# save_fig("Andamento nuovi casi fino all'23 giugno top 10 Paesi")
fig, axes = plt.subplots(2,5,sharex=True)
fig.set_size_inches(50,20)
for i in range (2):
for j in range (5):
axes[i,j].set_xticklabels([""," Feb","","Mar","","Apr","","Mag","","Giu"], rotation = 0)
fig.suptitle("Andamento casi Tot",fontsize=40)
axes[0,0].set_title("Brasile", fontsize=24)
axes[0,0].plot(COMPLETO['2020']['NuoviCasi Brasile'],'ko--',color='y')
axes[0,1].set_title("Chile", fontsize=24)
axes[0,1].plot(COMPLETO['2020']['NuoviCasi Chile'],'ko--',color='r')
axes[0,2].set_title("India", fontsize=24)
axes[0,2].plot(COMPLETO['2020']['NuoviCasi India'],'ko--',color='m')
axes[0,3].set_title("Iran", fontsize=24)
axes[0,3].plot(COMPLETO['2020']['NuoviCasi Iran'],'ko--',color='b')
axes[0,4].set_title("Italia", fontsize=24)
axes[0,4].plot(COMPLETO['2020']['NuoviCasi Italia'],'ko--',color='g')
axes[1,0].set_title("Perù", fontsize=24)
axes[1,0].plot(COMPLETO['2020']['NuoviCasi Perù'],'ko--',color='k')
axes[1,1].set_title("Russia", fontsize=24)
axes[1,1].plot(COMPLETO['2020']['NuoviCasi Russia'],'ko--',color='brown')
axes[1,2].set_title("Spagna", fontsize=24)
axes[1,2].plot(COMPLETO['2020']['NuoviCasi Spagna'],'ko--',color='purple')
axes[1,3].set_title("USA", fontsize=24)
axes[1,3].plot(COMPLETO['2020']['NuoviCasi USA'],'ko--',color='black')
axes[1,4].set_title("Regno_Unito", fontsize=24)
axes[1,4].plot(COMPLETO['2020']['NuoviCasi Regno_Unito'],'ko--',color='lightblue')
# save_fig("Andamento nuovi casi fino all'23 giugno top 10 Paesi singoli")
O=COMPLETO.reset_index()
fig, ((ax1, ax2),(ax3,ax4),(ax5, ax6),(ax7,ax8),(ax9,ax10)) = plt.subplots(5,2)
fig.set_size_inches(30, 22)
fig.suptitle("Andamento Nuovi casi Totale",fontsize=35)
x1, y1 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Brasile'], name="NuoviCasi Brasile")
sns.regplot(x=x1, y=y1, marker="+",ax=ax1,color='y')
x2, y2 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Chile'], name="NuoviCasi Chile")
sns.regplot(x=x2, y=y2,ax=ax2,color='r')
x3, y3 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi India'], name="NuoviCasi India")
sns.regplot(x=x3, y=y3, marker="*",ax=ax3,color='m')
x4, y4 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Iran'], name="NuoviCasi Iran")
sns.regplot(x=x4, y=y4,ax=ax4,color='b')
x5, y5 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Italia'], name="NuoviCasi Italia")
sns.regplot(x=x5, y=y5, marker=".",ax=ax5,color='g')
x6, y6 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Perù'], name="NuoviCasi Perù")
sns.regplot(x=x6, y=y6, marker="<",ax=ax6,color='k')
x7, y7 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Russia'], name="NuoviCasi Russia")
sns.regplot(x=x7, y=y7, marker=",",ax=ax7,color='brown')
x8, y8 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Spagna'], name="NuoviCasi Spagna")
sns.regplot(x=x8, y=y8, marker="^",ax=ax8,color='purple')
x9, y9 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi USA'], name="NuoviCasi USA")
sns.regplot(x=x9, y=y9, marker="|",ax=ax9,color='black')
x10, y10 = ps.Series(O.index, name="i-esima Giornata"), ps.Series(O['NuoviCasi Regno_Unito'], name="NuoviCasi Regno_Unito")
sns.regplot(x=x10, y=y10,ax=ax10)
# save_fig("Andamento nuovi casi fino all'23 giugno top 10 Paesi singoli regplot")
In più è possibile notare come l'andamento dei paesi nella maggior parte dei casi ha seguito una distribuzione normale o di Gaus,
anche se possiamo notare alcuni punti di outlier in alcuni paesi che raffigurano un rumore che può portare a definire cattive predizioni.
Attraverso la matrice di correlazione vediamo come sono correlate le varie nazioni andando a vedere il numero di nuovi casi positivi al virus giornaliero.
fig,ax = plt.subplots(figsize=(10,9))
fig = sns.heatmap(COMPLETO.corr(), annot=True,linewidths=.5,fmt='.3f')
plt.title("Dataset correlations", size=20)
plt.show()
figure = fig.get_figure()
# save_fig("Dataset correlations 1")
Vediamo che per esempio:
- l'italia ha una forte correlazione con Spagna.
- Il Regno Unito con gli USA
- Brasile con l'India
Prendiamo come data Iniziale sulla quale fare la predizione il 22-01-2020.
Da qui andiamo a definire un delta che sarà utile per costruire DELTA_i DataFrame che avranno al loro interno il numero di Casi a x + DELTA[i] giorni
Ogni Paese per ogni giorno avrà nella colonna yi il corrispettivo valore dei nuovi casi dopo Delta(i) giorni.
Sfrutto le proprietà Derivate dalle TimeSeries per prendere intervalli di date.
from datetime import timedelta
Delta=[1,2,3,4,5,6,7,8]
Y_1giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[0])):(datetime(2020, 6, 15)+timedelta(Delta[0]))].copy()
Y_2giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[1])):(datetime(2020, 6, 15)+timedelta(Delta[1]))].copy()
Y_3giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[2])):(datetime(2020, 6, 15)+timedelta(Delta[2]))].copy()
Y_4giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[3])):(datetime(2020, 6, 15)+timedelta(Delta[3]))].copy()
Y_5giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[4])):(datetime(2020, 6, 15)+timedelta(Delta[4]))].copy()
Y_6giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[5])):(datetime(2020, 6, 15)+timedelta(Delta[5]))].copy()
Y_7giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[6])):(datetime(2020, 6, 15)+timedelta(Delta[6]))].copy()
Y_8giorni_da_X=COMPLETO[(datetime(2020, 1, 22)+timedelta(Delta[7])):(datetime(2020, 6, 15)+timedelta(Delta[7]))].copy()
Y_8giorni_da_X
fig, ((ax1, ax2)) = plt.subplots(1,2, sharex=True)
fig.set_size_inches(20,10)
COMPLETO[:datetime(2020, 6, 15)].sort_index().plot(title="Giorno x",linewidth=2, markersize=20,ax=ax1)
NY_3giorni_da_X=Y_3giorni_da_X.copy()
NY_3giorni_da_X.index=COMPLETO[:(datetime(2020, 6, 15))].index
NY_3giorni_da_X.sort_index().plot(title="Giorno x+3",linewidth=2, markersize=20,ax=ax2)
# save_fig("Andamento giorno x e giorno x+3")
L'idea di lasciare che i dati guidino l'intero processo è allettante, tuttavia questo approccio può essere controproducente.
Per questo motivo, teniamo una parte dei dati che il nostro algoritmo non ha mai visto prima. Prima di fare ciò mi ridefifinisco i Dataframe in modo tale che alla fine avrò 10 Datateset:
-Ognuno di Questi DataFrame sarà indicativo di uno Stato nella Lista dei TOP_10
-Ogni Dataframe avrà 9 colonne , dove ogni riga sarà formata da:
-Valore giorno x,
-Valore giorno (x+1)-valore giorno (x)
-Valore giorno (x+2)-valore giorno (x)
-Valore giorno (x+3)-valore giorno (x)
-Valore giorno (x+4)-valore giorno (x)
-Valore giorno (x+5)-valore giorno (x)
-Valore giorno (x+6)-valore giorno (x)
-Valore giorno (x+7)-valore giorno (x)
-Valore giorno (x+8)-valore giorno (x)
D1=COMPLETO[:datetime(2020, 6, 15)].copy()
Y1=Y_1giorni_da_X.copy()
Y2=Y_2giorni_da_X.copy()
Y3=Y_3giorni_da_X.copy()
Y4=Y_4giorni_da_X.copy()
Y5=Y_5giorni_da_X.copy()
Y6=Y_6giorni_da_X.copy()
Y7=Y_7giorni_da_X.copy()
Y8=Y_8giorni_da_X.copy()
Stati=Y_1giorni_da_X.columns
def CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,i):
indice=D1.index
dx=np.array(D1[Stati[i]]).copy()
Dati={Stati[i]:D1[Stati[i]],
'Aumento CasiGiorno x+1':np.array(Y1[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+2':np.array(Y2[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+3':np.array(Y3[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+4':np.array(Y4[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+5':np.array(Y5[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+6':np.array(Y6[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+7':np.array(Y7[Stati[i]]).copy()-dx,
'Aumento CasiGiorno x+8':np.array(Y8[Stati[i]]).copy()-dx}
Res=ps.DataFrame(Dati,index=indice)
return Res
Brasile_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,0)
Chile_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,1)
India_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,2)
Iran_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,3)
Italia_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,4)
Perù_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,5)
Russia_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,6)
Spagna_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,7)
USA_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,8)
Regno_Unito_Pred=CreaD(D1,Y1,Y2,Y3,Y4,Y5,Y6,Y7,Y8,9)
Lista_Stati_Pred=[Brasile_Pred,Chile_Pred,India_Pred,Iran_Pred,Italia_Pred,Perù_Pred,Russia_Pred,Spagna_Pred,USA_Pred,Regno_Unito_Pred]
Lista_Stati_Pred[4][datetime(2020, 3, 20):datetime(2020, 3, 30)]
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
def Normalize (Lista,p):
for i in Lista:
x = i.values #returns a numpy array
x_scaled = p.fit_transform(x)
i = ps.DataFrame(x_scaled)
num_pipeline = Pipeline([
('std_scaler', StandardScaler()),
])
Normalize(Lista_Stati_Pred,num_pipeline)
Normalize([Y_1giorni_da_X,Y_2giorni_da_X,Y_3giorni_da_X,Y_4giorni_da_X,Y_5giorni_da_X,Y_6giorni_da_X,Y_7giorni_da_X,Y_8giorni_da_X],num_pipeline)
from sklearn.model_selection import train_test_split
train_set_X1, test_set_X1,train_set_X2, test_set_X2,train_set_X3, test_set_X3,train_set_X4, test_set_X4,train_set_X5, test_set_X5,train_set_X6, test_set_X6,train_set_X7, test_set_X7,train_set_X8, test_set_X8,train_set_X9, test_set_X9,train_set_X10, test_set_X10,train_set_Y1, test_set_Y1,train_set_Y2,test_set_Y2,train_set_Y3, test_set_Y3,train_set_Y4,test_set_Y4,train_set_Y5, test_set_Y5,train_set_Y6, test_set_Y6,train_set_Y7, test_set_Y7,train_set_Y8, test_set_Y8= train_test_split(Lista_Stati_Pred[0],Lista_Stati_Pred[1],Lista_Stati_Pred[2],Lista_Stati_Pred[3],Lista_Stati_Pred[4],Lista_Stati_Pred[5],Lista_Stati_Pred[6],Lista_Stati_Pred[7],Lista_Stati_Pred[8],Lista_Stati_Pred[9],Y_1giorni_da_X,Y_2giorni_da_X,Y_3giorni_da_X,Y_4giorni_da_X,Y_5giorni_da_X,Y_6giorni_da_X,Y_7giorni_da_X,Y_8giorni_da_X,test_size=0.3)
lista_Train=[train_set_X1,train_set_X2,train_set_X3,train_set_X4,train_set_X5,train_set_X6,train_set_X7,train_set_X8,train_set_X9, train_set_X10]
lista_TrainY=[train_set_Y1,train_set_Y2,train_set_Y3,train_set_Y4,train_set_Y5,train_set_Y6,train_set_Y7,train_set_Y8]
lista_Test=[test_set_X1,test_set_X2,test_set_X3,test_set_X4,test_set_X5,test_set_X6,test_set_X7,test_set_X8,test_set_X9,test_set_X10]
lista_TestY=[test_set_Y1,test_set_Y2,test_set_Y3,test_set_Y4,test_set_Y5,test_set_Y6,test_set_Y7,test_set_Y8]
print(len(train_set_X1), "train +", len(test_set_X1), "test")
from sklearn.model_selection import cross_val_predict, cross_val_score
from sklearn.metrics import*
def compute_performance(classifiers,names,X,y):
score_dict = {}
score_dict['Classifier'] = {}
score_dict['mse'] = {}
score_dict['variance']= {}
score_dict['mae']= {}
score_dict['median_se']= {}
score_dict['r2']= {}
k=0
for i in range(len(classifiers)):
value_predictions = classifiers[i].predict(X[k])
mse=0
variance=0
mae=0
median_se=0
r2=0
for yi in y:
stat=yi.columns
mse =mse+ mean_squared_error(yi[stat[k]], value_predictions)
variance =variance+ explained_variance_score(yi[stat[k]],value_predictions)
mae =mae+ mean_absolute_error(yi[stat[k]],value_predictions)
median_se =median_se+ median_absolute_error(yi[stat[k]], value_predictions)
r2 =r2+ r2_score(yi[stat[k]], value_predictions)
mse=mse/stat.size
variance=variance/stat.size
mae=mae/stat.size
median_se=median_se/stat.size
r2=r2/stat.size
name = names[i]
score_dict['Classifier'][i] = name
score_dict['mse'][i] = mse
score_dict['variance'][i] = variance
score_dict['mae'][i] = mae
score_dict['median_se'][i] = median_se
score_dict['r2'][i] = r2
k=k+1
if k==10:
k=0
return score_dict
Particolare metodo che richiamo durante la fase di addestramento, in modo tale che per ogni collonna del train_set, che corrisponde al numero di casi per un dato paese, venga addestrato sulla colonna rispettava ad ognuno dei Dataset derivati da DELTA:
regressor= []
names=[]
Stati=Y_1giorni_da_X.columns
Nstati=['Brasile','Chile','India','Iran','Italia','Perù','Russia','Spagna','USA','Regno_Unito']
def addestra(reg,xi,i):
Col=xi.columns
stat=Stati[i]
reg.fit(xi.loc[:, Col[0]:Col[1]], train_set_Y1[stat])
reg.fit(xi.loc[:, Col[0]:Col[2]], train_set_Y2[stat])
reg.fit(xi.loc[:, Col[0]:Col[3]], train_set_Y3[stat])
reg.fit(xi.loc[:, Col[0]:Col[4]], train_set_Y4[stat])
reg.fit(xi.loc[:, Col[0]:Col[5]], train_set_Y5[stat])
reg.fit(xi.loc[:, Col[0]:Col[6]], train_set_Y6[stat])
reg.fit(xi.loc[:, Col[0]:Col[7]], train_set_Y7[stat])
reg.fit(xi.loc[:, Col[0]:Col[8]], train_set_Y8[stat])
from sklearn.linear_model import LinearRegression
for i in range (10):
lin_reg = LinearRegression()
addestra(lin_reg,lista_Train[i],i)
regressor.append(lin_reg)
names.append("Linear Regressor "+Nstati[i])
from sklearn.linear_model import HuberRegressor
for i in range (10):
Huber_reg = HuberRegressor()
addestra(Huber_reg,lista_Train[i],i)
regressor.append(Huber_reg)
names.append("Huber Regressor "+Nstati[i])
from sklearn.linear_model import BayesianRidge
for i in range (10):
BayesianRidge_reg = BayesianRidge()
addestra(BayesianRidge_reg,lista_Train[i],i)
regressor.append(BayesianRidge_reg)
names.append("BayesianRidge Regressor "+Nstati[i])
from sklearn.tree import DecisionTreeRegressor
for i in range (10):
DecisionTreeRegressor_reg = DecisionTreeRegressor()
addestra(DecisionTreeRegressor_reg,lista_Train[i],i)
regressor.append(DecisionTreeRegressor_reg)
names.append("DecisionTree Regressor "+Nstati[i])
from sklearn.tree import ExtraTreeRegressor
for i in range (10):
ExtraTreeRegressor_reg = ExtraTreeRegressor()
addestra(ExtraTreeRegressor_reg,lista_Train[i],i)
regressor.append(ExtraTreeRegressor_reg)
names.append("ExtraTree Regressor "+Nstati[i])
from sklearn.neighbors import KNeighborsRegressor
for i in range (10):
KNeighborsRegressor_reg = KNeighborsRegressor()
addestra(KNeighborsRegressor_reg,lista_Train[i],i)
regressor.append(KNeighborsRegressor_reg)
names.append("KNeighbors Regressor "+Nstati[i])
from sklearn.ensemble import RandomForestRegressor
for i in range (10):
RandomForestRegressor_reg = RandomForestRegressor()
addestra(RandomForestRegressor_reg,lista_Train[i],i)
regressor.append(RandomForestRegressor_reg)
names.append("RandomForest Regressor "+Nstati[i])
from sklearn.ensemble import AdaBoostRegressor
for i in range (10):
AdaBoostRegressor_reg = AdaBoostRegressor()
addestra(AdaBoostRegressor_reg,lista_Train[i],i)
regressor.append(AdaBoostRegressor_reg)
names.append("AdaBoost Regressor "+Nstati[i])
from sklearn.ensemble import GradientBoostingRegressor
for i in range (10):
GradientBoostingRegressor_reg = GradientBoostingRegressor()
addestra(GradientBoostingRegressor_reg,lista_Train[i],i)
regressor.append(GradientBoostingRegressor_reg)
names.append("GradientBoosting Regressor "+Nstati[i])
from sklearn.ensemble import BaggingRegressor
for i in range (10):
BaggingRegressor_reg = BaggingRegressor()
addestra(BaggingRegressor_reg,lista_Train[i],i)
regressor.append(BaggingRegressor_reg)
names.append("Bagging Regressor "+Nstati[i])
from sklearn.svm import SVR
for i in range (10):
SVR_reg = SVR()
addestra(SVR_reg,lista_Train[i],i)
regressor.append(SVR_reg)
names.append("SVR Regressor "+Nstati[i])
from sklearn.neural_network import MLPRegressor
for i in range (10):
MLPRegressor_reg = MLPRegressor()
addestra(MLPRegressor_reg,lista_Train[i],i)
regressor.append(MLPRegressor_reg)
names.append("MLP Regressor "+Nstati[i])
score_dict_train = compute_performance(regressor, names, lista_Train,lista_TrainY)
score_df_train = ps.DataFrame(score_dict_train)
score_df_train_Brasile=score_df_train.iloc[lambda x: x.index % 10 == 0].reset_index(drop=True)
score_df_train_Chile=score_df_train.iloc[lambda x: x.index % 10 == 1].reset_index(drop=True)
score_df_train_India=score_df_train.iloc[lambda x: x.index % 10 == 2].reset_index(drop=True)
score_df_train_Iran=score_df_train.iloc[lambda x: x.index % 10 == 3].reset_index(drop=True)
score_df_train_Italia=score_df_train.iloc[lambda x: x.index % 10 == 4].reset_index(drop=True)
score_df_train_Perù=score_df_train.iloc[lambda x: x.index % 10 == 5].reset_index(drop=True)
score_df_train_Russia=score_df_train.iloc[lambda x: x.index % 10 == 6].reset_index(drop=True)
score_df_train_Spagna=score_df_train.iloc[lambda x: x.index % 10 == 7].reset_index(drop=True)
score_df_train_USA=score_df_train.iloc[lambda x: x.index % 10 == 8].reset_index(drop=True)
score_df_train_Regno_Unito=score_df_train.iloc[lambda x: x.index % 10 == 9].reset_index(drop=True)
score_df_train_USA
score_dict_test = compute_performance(regressor, names, lista_Test,lista_TestY)
score_df_test = ps.DataFrame(score_dict_test)
score_df_test_Brasile=score_df_test.iloc[lambda x: x.index % 10 == 0].reset_index(drop=True)
score_df_test_Chile=score_df_test.iloc[lambda x: x.index % 10 == 1].reset_index(drop=True)
score_df_test_India=score_df_test.iloc[lambda x: x.index % 10 == 2].reset_index(drop=True)
score_df_test_Iran=score_df_test.iloc[lambda x: x.index % 10 == 3].reset_index(drop=True)
score_df_test_Italia=score_df_test.iloc[lambda x: x.index % 10 == 4].reset_index(drop=True)
score_df_test_Perù=score_df_test.iloc[lambda x: x.index % 10 == 5].reset_index(drop=True)
score_df_test_Russia=score_df_test.iloc[lambda x: x.index % 10 == 6].reset_index(drop=True)
score_df_test_Spagna=score_df_test.iloc[lambda x: x.index % 10 == 7].reset_index(drop=True)
score_df_test_USA=score_df_test.iloc[lambda x: x.index % 10 == 8].reset_index(drop=True)
score_df_test_Regno_Unito=score_df_test.iloc[lambda x: x.index % 10 == 9].reset_index(drop=True)
score_df_test_Spagna
UTILIZZO QUESTI DUE METODI, OSSIA PLOT() E Function() PER FACILITARE LA FASE STAMPA E DI CREAZIONE DEI SINGOLI PLOT
def PLOT(train,test,title,ax,S):
width = 0.50
i = np.arange(len(train))
train_bars = ax.bar(i, train, width,)
test_bars = ax.bar(i+width, test, width)
ax.set_title(title,fontsize=15)
ax.set_xticklabels(S.Classifier, rotation = 90)
ax.set_xticks(i + width / 2)
ax.legend((train_bars,test_bars),('Train','Test'),fontsize=14)
plt.plot()
def Function(score,test,ax1,ax2,ax3,ax4,ax5):
PLOT(score.mse,test.mse,'mse Train VS Test',ax1,score)
PLOT(score.variance,test.variance,'variance Train VS Test',ax2,score)
PLOT(score.mae,test.mae,'mae Train VS Test',ax3,score)
PLOT(score.median_se,test.median_se,'median_se Train VS Test',ax4,score)
PLOT(score.r2,test.r2,'r2 Train VS Test',ax5,score)
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Brasile', fontsize=17)
Function(score_df_train_Brasile,score_df_test_Brasile,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Brasile")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Chile', fontsize=17)
Function(score_df_train_Chile,score_df_test_Chile,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Chile")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore India', fontsize=17)
Function(score_df_train_India,score_df_test_India,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore India")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Iran', fontsize=17)
Function(score_df_train_Iran,score_df_test_Iran,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Iran")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Italia', fontsize=17)
Function(score_df_train_Italia,score_df_test_Italia,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Italia")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Perù', fontsize=17)
Function(score_df_train_Perù,score_df_test_Perù,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Perù")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Russia', fontsize=17)
Function(score_df_train_Russia,score_df_test_Russia,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Russia")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Spagna', fontsize=17)
Function(score_df_train_Spagna,score_df_test_Spagna,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Spagna")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore USA', fontsize=17)
Function(score_df_train_USA,score_df_test_USA,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore USA")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.set_size_inches(20,7)
fig.suptitle('Train VS Test Errore classificatore Regno_Unito', fontsize=17)
Function(score_df_train_Regno_Unito,score_df_test_Regno_Unito,ax1,ax2,ax3,ax4,ax5)
# save_fig("Train VS Test Errore classificatore Regno_Unito")
Nuovi_Casi_Andamento_TOT=ts.copy()
m=0
LISTA= np.array(Nuovi_Casi_Andamento_TOT['Paese'])
L=Casi_tot_TOP_10.index
for i in LISTA:
if i!=L[0] and i!=L[1] and i!=L[2] and i!=L[3] and i!=L[4] and i!=L[5] and i!=L[6] and i!=L[7] and i!=L[8] and i!=L[9]:
Nuovi_Casi_Andamento_TOT.iloc[m] = np.nan
m=m+1
Nuovi_Casi_Andamento_TOT=Nuovi_Casi_Andamento_TOT.dropna()
Nuovi_Casi_Andamento_TOT
Non tengo conto dell'attributo pese poichè è difficile da binarizzare e inoltre è poco rilevante.
Bin=ps.get_dummies(Nuovi_Casi_Andamento_TOT.Lockdown)
dati={"Paese":np.array(Nuovi_Casi_Andamento_TOT['Paese']),
"Confermati":np.array(Nuovi_Casi_Andamento_TOT.Confermati),
"Nuovi casi":np.array(Nuovi_Casi_Andamento_TOT["Nuovi casi"]),
"Ricoverati":np.array(Nuovi_Casi_Andamento_TOT.Ricoverati),
"Nuovi Ricoverati":np.array(Nuovi_Casi_Andamento_TOT["Nuovi Ricoverati"]),
"Morti":np.array(Nuovi_Casi_Andamento_TOT.Morti),
"Nuovi morti":np.array(Nuovi_Casi_Andamento_TOT["Nuovi morti"]),
"Lockdown ":np.array(Bin.TOTALE)
}
dates=Nuovi_Casi_Andamento_TOT.index
Nuovi_Casi_Andamento_TOT=ps.DataFrame(dati,index=dates)
Nuovi_Casi_Andamento_TOT
Attraverso la matrice di correlazione vediamo come sono correlate le varie nazioni andando a vedere i dati giornalieri.
fig,ax = plt.subplots(figsize=(10,9))
fig = sns.heatmap(Nuovi_Casi_Andamento_TOT.corr(), annot=True,linewidths=.5,fmt='.3f')
plt.title("Dataset correlations", size=20)
plt.show()
figure = fig.get_figure()
# save_fig("Dataset correlations 2")
Notiamo di avere una Fortissima correlazione tra i dati.
Ovviamente risulta poca correlazione nel caso del LockDown poichè come abbiamo gia osservato soprà non è un attributo che dà una forte impronta sui valori delle altre colonne.
Prendiamo come data Iniziale sulla quale fare la predizione il 22-01-2020.
Da qui andiamo a definire un delta che sarà utile per costruire DELTA_i DataFrame che avranno al loro interno i valori delle tuple traslati a x + DELTA[i] giorni
Ogni Paese per ogni giorno avrà nella colonna yi il corrispettivo valore dei nuovi casi dopo Delta(i) giorni.
Sfrutto le proprietà Derivate dalle TimeSeries per prendere intervalli di date.
from datetime import timedelta
Delta=[1,2,3,4,5,6,7,8]
Y_1giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[0])):(datetime(2020, 6, 15)+timedelta(Delta[0]))].copy()
Y_1giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_2giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[1])):(datetime(2020, 6, 15)+timedelta(Delta[1]))].copy()
Y_2giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_3giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[2])):(datetime(2020, 6, 15)+timedelta(Delta[2]))].copy()
Y_3giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_4giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[3])):(datetime(2020, 6, 15)+timedelta(Delta[3]))].copy()
Y_4giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_5giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[4])):(datetime(2020, 6, 15)+timedelta(Delta[4]))].copy()
Y_5giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_6giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[5])):(datetime(2020, 6, 15)+timedelta(Delta[5]))].copy()
Y_6giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_7giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[6])):(datetime(2020, 6, 15)+timedelta(Delta[6]))].copy()
Y_7giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_8giorni_da_X=Nuovi_Casi_Andamento_TOT[(datetime(2020, 1, 22)+timedelta(Delta[7])):(datetime(2020, 6, 15)+timedelta(Delta[7]))].copy()
Y_8giorni_da_X.index=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)].index
Y_8giorni_da_X
L'idea di lasciare che i dati guidino l'intero processo è allettante, tuttavia questo approccio può essere controproducente.
Per questo motivo, teniamo una parte dei dati che il nostro algoritmo non ha mai visto prima.Prima di fare ciò mi ridefinisco il Dataframe che sarà addestrato:
-Questo DataFrame sarà indicativo di ogni Stato nella Lista dei TOP_10
-Ogni Dataframe avrà 8 colonne , relativi agli attributi :
-[Confermati,Nuovi casi,Ricoverati,Nuovi Ricoverati,Morti,Nuovi morti,Lockdown]
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
def Normalize (Lista,p):
for i in Lista:
I = i.values #returns a numpy array
x_scaled = p.fit_transform(I)
i = ps.DataFrame(x_scaled)
num_pipeline = Pipeline([
('std_scaler', StandardScaler()),
])
x=Nuovi_Casi_Andamento_TOT[:datetime(2020, 6, 15)]
del x['Paese']
y1=ps.DataFrame(Y_1giorni_da_X['Nuovi casi'])
y2=ps.DataFrame(Y_2giorni_da_X['Nuovi casi'])
y3=ps.DataFrame(Y_3giorni_da_X['Nuovi casi'])
y4=ps.DataFrame(Y_4giorni_da_X['Nuovi casi'])
y5=ps.DataFrame(Y_5giorni_da_X['Nuovi casi'])
y6=ps.DataFrame(Y_6giorni_da_X['Nuovi casi'])
y7=ps.DataFrame(Y_7giorni_da_X['Nuovi casi'])
y8=ps.DataFrame(Y_8giorni_da_X['Nuovi casi'])
Normalize([x],num_pipeline)
Normalize([y1,y2,y3,y4,y5,y6,y7,y8],num_pipeline)
import numpy as np
from sklearn.model_selection import train_test_split
train_set_X, test_set_X,train_set_Y1, test_set_Y1,train_set_Y2, test_set_Y2,train_set_Y3, test_set_Y3,train_set_Y4, test_set_Y4,train_set_Y5, test_set_Y5,train_set_Y6, test_set_Y6,train_set_Y7, test_set_Y7,train_set_Y8, test_set_Y8= train_test_split(x,y1,y2,y3,y4,y5,y6,y7,y8,test_size=0.3)
print("",len(train_set_X), "trainX +", len(test_set_X), "testX\n",len(train_set_Y1), "trainY1 +", len(test_set_Y1), "testY1\n",len(train_set_Y2), "trainY2 +", len(test_set_Y2), "testY2\n",
len(train_set_Y3), "trainY3 +", len(test_set_Y3), "testY3\n",len(train_set_Y4), "trainY4 +", len(test_set_Y4), "testY4\n",len(train_set_Y5), "trainY5 +", len(test_set_Y5), "testY5\n",
len(train_set_Y6), "trainY6 +", len(test_set_Y6), "testY6\n",len(train_set_Y7), "trainY7 +", len(test_set_Y7), "testY7\n",len(train_set_Y8), "trainY8 +", len(test_set_Y8), "testY8\n")
from sklearn.model_selection import cross_val_predict, cross_val_score
from sklearn.metrics import*
import time
def compute_performance(classifiers,names,X,Y):
score_dict = {}
score_dict['Classifier'] = {}
score_dict['mse'] = {}
score_dict['variance']= {}
score_dict['mae']= {}
score_dict['median_se']= {}
score_dict['r2']= {}
j=0
for i in range(len(classifiers)):
value_predictions = classifiers[i].predict(X)
if j==8:
j=0
y=Y[j]
mse = mean_squared_error(y, value_predictions)
variance = explained_variance_score(y,value_predictions)
mae = mean_absolute_error(y,value_predictions)
median_se = median_absolute_error(y, value_predictions)
r2 = r2_score(y, value_predictions)
name = names[i]
score_dict['Classifier'][i] = name
score_dict['mse'][i] = mse
score_dict['variance'][i] = variance
score_dict['mae'][i] = mae
score_dict['median_se'][i] = median_se
score_dict['r2'][i] = r2
j=j+1
return score_dict
Particolare metodo che richiamo durante la fase di addestramento, in modo tale che addestrò su ogni regressore degli 8 il train set, in base al corrispettivo TrainSet a distanza di DELTA[i] giorni:
regressor= []
names=[]
def addestra(reg1,reg2,reg3,reg4,reg5,reg6,reg7,reg8,L):
reg1.fit(train_set_X, train_set_Y1)
reg2.fit(train_set_X, train_set_Y2)
reg3.fit(train_set_X, train_set_Y3)
reg4.fit(train_set_X, train_set_Y4)
reg5.fit(train_set_X, train_set_Y5)
reg6.fit(train_set_X, train_set_Y6)
reg7.fit(train_set_X, train_set_Y7)
reg8.fit(train_set_X, train_set_Y8)
REG=[reg1,reg2,reg3,reg4,reg5,reg6,reg7,reg8]
for i in range(8):
regressor.append(REG[i])
names.append(L[i])
from sklearn.linear_model import LinearRegression
lin_reg1 = LinearRegression()
lin_reg2 = LinearRegression()
lin_reg3 = LinearRegression()
lin_reg4 = LinearRegression()
lin_reg5 = LinearRegression()
lin_reg6 = LinearRegression()
lin_reg7 = LinearRegression()
lin_reg8 = LinearRegression()
n=["Linear Regressor x+1","Linear Regressor x+2","Linear Regressor x+3","Linear Regressor x+4","Linear Regressor x+5","Linear Regressor x+6","Linear Regressor x+7","Linear Regressor x+8"]
addestra(lin_reg1,lin_reg2,lin_reg3,lin_reg4,lin_reg5,lin_reg6,lin_reg7,lin_reg8,n)
from sklearn.linear_model import HuberRegressor
Huber_reg1 = HuberRegressor()
Huber_reg2 = HuberRegressor()
Huber_reg3 = HuberRegressor()
Huber_reg4 = HuberRegressor()
Huber_reg5 = HuberRegressor()
Huber_reg6 = HuberRegressor()
Huber_reg7 = HuberRegressor()
Huber_reg8 = HuberRegressor()
n=["Huber Regressor x+1","Huber Regressor x+2","Huber Regressor x+3","Huber Regressor x+4","Huber Regressor x+5","Huber Regressor x+6","Huber Regressor x+7","Huber Regressor x+8"]
addestra(Huber_reg1,Huber_reg2,Huber_reg3,Huber_reg4,Huber_reg5,Huber_reg6,Huber_reg7,Huber_reg8,n)
from sklearn.linear_model import BayesianRidge
BayesianRidge_reg1 = BayesianRidge()
BayesianRidge_reg2 = BayesianRidge()
BayesianRidge_reg3 = BayesianRidge()
BayesianRidge_reg4 = BayesianRidge()
BayesianRidge_reg5 = BayesianRidge()
BayesianRidge_reg6 = BayesianRidge()
BayesianRidge_reg7 = BayesianRidge()
BayesianRidge_reg8 = BayesianRidge()
n=["BayesianRidge Regressor x+1","BayesianRidge Regressor x+2","BayesianRidge Regressor x+3","BayesianRidge Regressor x+4","BayesianRidge Regressor x+5","BayesianRidge Regressor x+6","BayesianRidge Regressor x+7","BayesianRidge Regressor x+8"]
addestra(BayesianRidge_reg1,BayesianRidge_reg2,BayesianRidge_reg3,BayesianRidge_reg4,BayesianRidge_reg5,BayesianRidge_reg6,BayesianRidge_reg7,BayesianRidge_reg8,n)
from sklearn.tree import DecisionTreeRegressor
DecisionTreeRegressor_reg1 = DecisionTreeRegressor()
DecisionTreeRegressor_reg2 = DecisionTreeRegressor()
DecisionTreeRegressor_reg3 = DecisionTreeRegressor()
DecisionTreeRegressor_reg4 = DecisionTreeRegressor()
DecisionTreeRegressor_reg5 = DecisionTreeRegressor()
DecisionTreeRegressor_reg6 = DecisionTreeRegressor()
DecisionTreeRegressor_reg7 = DecisionTreeRegressor()
DecisionTreeRegressor_reg8 = DecisionTreeRegressor()
n=["DecisionTree Regressor x+1","DecisionTree Regressor x+2","DecisionTree Regressor x+3","DecisionTree Regressor x+4","DecisionTree Regressor x+5","DecisionTree Regressor x+6","DecisionTree Regressor x+7","DecisionTree Regressor x+8"]
addestra(DecisionTreeRegressor_reg1,DecisionTreeRegressor_reg2,DecisionTreeRegressor_reg3,DecisionTreeRegressor_reg4,DecisionTreeRegressor_reg5,DecisionTreeRegressor_reg6,DecisionTreeRegressor_reg7,DecisionTreeRegressor_reg8,n)
from sklearn.tree import ExtraTreeRegressor
ExtraTreeRegressor_reg1 = ExtraTreeRegressor()
ExtraTreeRegressor_reg2 = ExtraTreeRegressor()
ExtraTreeRegressor_reg3 = ExtraTreeRegressor()
ExtraTreeRegressor_reg4 = ExtraTreeRegressor()
ExtraTreeRegressor_reg5 = ExtraTreeRegressor()
ExtraTreeRegressor_reg6 = ExtraTreeRegressor()
ExtraTreeRegressor_reg7 = ExtraTreeRegressor()
ExtraTreeRegressor_reg8 = ExtraTreeRegressor()
n=["ExtraTree Regressor x+1","ExtraTree Regressor x+2","ExtraTree Regressor x+3","ExtraTree Regressor x+4","ExtraTree Regressor x+5","ExtraTree Regressor x+6","ExtraTree Regressor x+7","ExtraTree Regressor x+8"]
addestra(ExtraTreeRegressor_reg1,ExtraTreeRegressor_reg2,ExtraTreeRegressor_reg3,ExtraTreeRegressor_reg4,ExtraTreeRegressor_reg5,ExtraTreeRegressor_reg6,ExtraTreeRegressor_reg7,ExtraTreeRegressor_reg8,n)
from sklearn.neighbors import KNeighborsRegressor
KNeighborsRegressor_reg1 = KNeighborsRegressor()
KNeighborsRegressor_reg2 = KNeighborsRegressor()
KNeighborsRegressor_reg3 = KNeighborsRegressor()
KNeighborsRegressor_reg4 = KNeighborsRegressor()
KNeighborsRegressor_reg5 = KNeighborsRegressor()
KNeighborsRegressor_reg6 = KNeighborsRegressor()
KNeighborsRegressor_reg7 = KNeighborsRegressor()
KNeighborsRegressor_reg8 = KNeighborsRegressor()
n=["KNeighbors Regressor x+1","KNeighbors Regressor x+2","KNeighbors Regressor x+3","KNeighbors Regressor x+4","KNeighbors Regressor x+5","KNeighbors Regressor x+6","KNeighbors Regressor x+7","KNeighbors Regressor x+8"]
addestra(KNeighborsRegressor_reg1,KNeighborsRegressor_reg2,KNeighborsRegressor_reg3,KNeighborsRegressor_reg4,KNeighborsRegressor_reg5,KNeighborsRegressor_reg6,KNeighborsRegressor_reg7,KNeighborsRegressor_reg8,n)
from sklearn.ensemble import RandomForestRegressor
RandomForestRegressor_reg1 = RandomForestRegressor()
RandomForestRegressor_reg2 = RandomForestRegressor()
RandomForestRegressor_reg3 = RandomForestRegressor()
RandomForestRegressor_reg4 = RandomForestRegressor()
RandomForestRegressor_reg5 = RandomForestRegressor()
RandomForestRegressor_reg6 = RandomForestRegressor()
RandomForestRegressor_reg7 = RandomForestRegressor()
RandomForestRegressor_reg8 = RandomForestRegressor()
n=["RandomForest Regressor x+1","RandomForest Regressor x+2","RandomForest Regressor x+3","RandomForest Regressor x+4","RandomForest Regressor x+5","RandomForest Regressor x+6","RandomForest Regressor x+7","RandomForest Regressor x+8"]
addestra(RandomForestRegressor_reg1,RandomForestRegressor_reg2,RandomForestRegressor_reg3,RandomForestRegressor_reg4,RandomForestRegressor_reg5,RandomForestRegressor_reg6,RandomForestRegressor_reg7,RandomForestRegressor_reg8,n)
from sklearn.ensemble import AdaBoostRegressor
AdaBoostRegressor_reg1 = AdaBoostRegressor()
AdaBoostRegressor_reg2 = AdaBoostRegressor()
AdaBoostRegressor_reg3 = AdaBoostRegressor()
AdaBoostRegressor_reg4 = AdaBoostRegressor()
AdaBoostRegressor_reg5 = AdaBoostRegressor()
AdaBoostRegressor_reg6 = AdaBoostRegressor()
AdaBoostRegressor_reg7 = AdaBoostRegressor()
AdaBoostRegressor_reg8 = AdaBoostRegressor()
n=["AdaBoost Regressor x+1","AdaBoost Regressor x+2","AdaBoost Regressor x+3","AdaBoost Regressor x+4","AdaBoost Regressor x+5","AdaBoost Regressor x+6","AdaBoost Regressor x+7","AdaBoost Regressor x+8"]
addestra(AdaBoostRegressor_reg1,AdaBoostRegressor_reg2,AdaBoostRegressor_reg3,AdaBoostRegressor_reg4,AdaBoostRegressor_reg5,AdaBoostRegressor_reg6,AdaBoostRegressor_reg7,AdaBoostRegressor_reg8,n)
from sklearn.ensemble import GradientBoostingRegressor
GradientBoostingRegressor_reg1 = GradientBoostingRegressor()
GradientBoostingRegressor_reg2 = GradientBoostingRegressor()
GradientBoostingRegressor_reg3 = GradientBoostingRegressor()
GradientBoostingRegressor_reg4 = GradientBoostingRegressor()
GradientBoostingRegressor_reg5 = GradientBoostingRegressor()
GradientBoostingRegressor_reg6 = GradientBoostingRegressor()
GradientBoostingRegressor_reg7 = GradientBoostingRegressor()
GradientBoostingRegressor_reg8 = GradientBoostingRegressor()
n=["GradientBoosting Regressor x+1","GradientBoosting Regressor x+2","GradientBoosting Regressor x+3","GradientBoosting Regressor x+4","GradientBoosting Regressor x+5","GradientBoosting Regressor x+6","GradientBoosting Regressor x+7","GradientBoosting Regressor x+8"]
addestra(GradientBoostingRegressor_reg1,GradientBoostingRegressor_reg2,GradientBoostingRegressor_reg3,GradientBoostingRegressor_reg4,GradientBoostingRegressor_reg5,GradientBoostingRegressor_reg6,GradientBoostingRegressor_reg7,GradientBoostingRegressor_reg8,n)
from sklearn.ensemble import BaggingRegressor
BaggingRegressor_reg1= BaggingRegressor()
BaggingRegressor_reg2= BaggingRegressor()
BaggingRegressor_reg3= BaggingRegressor()
BaggingRegressor_reg4= BaggingRegressor()
BaggingRegressor_reg5= BaggingRegressor()
BaggingRegressor_reg6= BaggingRegressor()
BaggingRegressor_reg7= BaggingRegressor()
BaggingRegressor_reg8= BaggingRegressor()
n=["Bagging Regressor x+1","Bagging Regressor x+2","Bagging Regressor x+3","Bagging Regressor x+4","Bagging Regressor x+5","Bagging Regressor x+6","Bagging Regressor x+7","Bagging Regressor x+8"]
addestra(BaggingRegressor_reg1,BaggingRegressor_reg2,BaggingRegressor_reg3,BaggingRegressor_reg4,BaggingRegressor_reg5,BaggingRegressor_reg6,BaggingRegressor_reg7,BaggingRegressor_reg8,n)
from sklearn.svm import SVR
SVR_reg1 = SVR()
SVR_reg2 = SVR()
SVR_reg3 = SVR()
SVR_reg4 = SVR()
SVR_reg5 = SVR()
SVR_reg6 = SVR()
SVR_reg7 = SVR()
SVR_reg8 = SVR()
n=["SVR Regressor x+1","SVR Regressor x+2","SVR Regressor x+3","SVR Regressor x+4","SVR Regressor x+5","SVR Regressor x+6","SVR Regressor x+7","SVR Regressor x+8"]
addestra(SVR_reg1,SVR_reg2,SVR_reg3,SVR_reg4,SVR_reg5,SVR_reg6,SVR_reg7,SVR_reg8,n)
from sklearn.neural_network import MLPRegressor
MLPRegressor_reg1 = MLPRegressor()
MLPRegressor_reg2 = MLPRegressor()
MLPRegressor_reg3 = MLPRegressor()
MLPRegressor_reg4 = MLPRegressor()
MLPRegressor_reg5 = MLPRegressor()
MLPRegressor_reg6 = MLPRegressor()
MLPRegressor_reg7 = MLPRegressor()
MLPRegressor_reg8 = MLPRegressor()
n=["MLP Regressor x+1","MLP Regressor x+2","MLP Regressor x+3","MLP Regressor x+4","MLP Regressor x+5","MLP Regressor x+6","MLP Regressor x+7","MLP Regressor x+8"]
addestra(MLPRegressor_reg1,MLPRegressor_reg2,MLPRegressor_reg3,MLPRegressor_reg4,MLPRegressor_reg5,MLPRegressor_reg6,MLPRegressor_reg7,MLPRegressor_reg8,n)
yT=[train_set_Y1,train_set_Y2,train_set_Y3,train_set_Y4,train_set_Y5,train_set_Y6,train_set_Y7,train_set_Y8]
score_dict_train = compute_performance(regressor, names, train_set_X,yT)
score_df_train = ps.DataFrame(score_dict_train)
score_df_train_DELTA1=score_df_train.iloc[lambda x: x.index % 8 == 0].reset_index(drop=True)
score_df_train_DELTA2=score_df_train.iloc[lambda x: x.index % 8 == 1].reset_index(drop=True)
score_df_train_DELTA3=score_df_train.iloc[lambda x: x.index % 8 == 2].reset_index(drop=True)
score_df_train_DELTA4=score_df_train.iloc[lambda x: x.index % 8 == 3].reset_index(drop=True)
score_df_train_DELTA5=score_df_train.iloc[lambda x: x.index % 8 == 4].reset_index(drop=True)
score_df_train_DELTA6=score_df_train.iloc[lambda x: x.index % 8 == 5].reset_index(drop=True)
score_df_train_DELTA7=score_df_train.iloc[lambda x: x.index % 8 == 6].reset_index(drop=True)
score_df_train_DELTA8=score_df_train.iloc[lambda x: x.index % 8 == 7].reset_index(drop=True)
score_df_train_DELTA1
yTest=[test_set_Y1,test_set_Y2,test_set_Y3,test_set_Y4,test_set_Y5,test_set_Y6,test_set_Y7,test_set_Y8]
score_dict_test = compute_performance(regressor,names,test_set_X,yTest)
score_df_test = ps.DataFrame(score_dict_test)
score_df_test_DELTA1=score_df_test.iloc[lambda x: x.index % 8 == 0].reset_index(drop=True)
score_df_test_DELTA2=score_df_test.iloc[lambda x: x.index % 8 == 1].reset_index(drop=True)
score_df_test_DELTA3=score_df_test.iloc[lambda x: x.index % 8 == 2].reset_index(drop=True)
score_df_test_DELTA4=score_df_test.iloc[lambda x: x.index % 8 == 3].reset_index(drop=True)
score_df_test_DELTA5=score_df_test.iloc[lambda x: x.index % 8 == 4].reset_index(drop=True)
score_df_test_DELTA6=score_df_test.iloc[lambda x: x.index % 8 == 5].reset_index(drop=True)
score_df_test_DELTA7=score_df_test.iloc[lambda x: x.index % 8 == 6].reset_index(drop=True)
score_df_test_DELTA8=score_df_test.iloc[lambda x: x.index % 8 == 7].reset_index(drop=True)
score_df_test_DELTA8
UTILIZZO QUESTI i DUE METODI SOPRA DEFINITI, OSSIA PLOT() E Function() PER FACILITARE LA FASE STAMPA E LA CREAZIONE DEI SINGOLI PLOT.
OGNI PLOT RAFFIGURERA' L'ERRORE COMMESSO DA OGNI REGRESSORE A DISTANZA DI DELTA[I] GIORNI
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+1 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA1,score_df_test_DELTA1,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+1 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+2 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA2,score_df_test_DELTA2,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+2 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+3 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA3,score_df_test_DELTA3,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+3 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+4 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA4,score_df_test_DELTA4,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+4 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+5 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA5,score_df_test_DELTA5,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+5 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+6 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA6,score_df_test_DELTA6,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+6 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+7 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA7,score_df_test_DELTA7,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+7 giorni")
fig, ((ax1, ax2,ax3,ax4,ax5)) = plt.subplots(1,5, sharex=True)
fig.suptitle("Errore nella Predizione dei casi a x+8 giorni",fontsize=25)
fig.set_size_inches(30,7)
Function(score_df_train_DELTA8,score_df_test_DELTA8,ax1,ax2,ax3,ax4,ax5)
# save_fig("Errore nella Predizione dei casi a x+8 giorni")
Com'era normale aspettarsi, sul test set si ottengono risultati leggermente peggiori in certi casi, dovuti al fatto che il train set è il dataset su cui gli algoritmi si sono addestrati. Nonostante ciò, non si notano grandi differenze tra test e train, concludendo quindi che il processo di regressione è corretto.
Possiamo in più notare che utilizzando come train_set da addestrare un DataFrame che possiede più dati anzicchè i singoli nuoviCasi e gli aumenti o decrementi di essi a distanza di x+DELTA[i] giorni, otteniamo Performance migliori.
Questo è dovuto alla forte correlazione che vi è tra gli attributi del nostro DataFrame da ddestrare: [Confermati,Nuovi casi,Ricoverati,Nuovi Ricoverati,Morti,Nuovi morti,Lockdown]